const bcrypt = require('bcryptjs');
const db = require('../core/mysql/db.js');
const ApiResponse = require('../util/ApiResponseUtil.js');
const jwt = require('jsonwebtoken');

/**
 * 处理用户列表查询请求
 * @param {Object} req - HTTP请求对象
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回用户列表数据的API响应
 */
exports.handleUserListing = async (req, res) => {
    const sql = 'SELECT id, username, nickname, email, avatar FROM users';
    const [users] = await db.query(sql);
    if (users.length === 0) {
        return res.send(ApiResponse.success(200, '用户列表为空'));

    }
    return res.send(ApiResponse.success(200, '用户列表获取成功'));
};

/**
 * 处理根据ID查询用户请求
 * @param {Object} req - HTTP请求对象，包含params参数
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回指定ID用户数据的API响应
 */
exports.handleUserByToken = async (req, res) => {
    const sql = 'SELECT id, username, nickname, email, avatar, create_at, update_at FROM users WHERE id = ?';
    const [user] = await db.query(sql, [req.auth.id]);
    if (user.length === 0) {
        return res.send(ApiResponse.error(201, '未识别到该用户'));
    }
    return res.send(ApiResponse.success(200, '用户信息获取成功', user[0]));

};

/**
 * 处理根据ID查询用户请求
 * @param {Object} req - HTTP请求对象，包含params参数
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回指定ID用户数据的API响应
 */
exports.handleUserById = async (req, res) => {
    const sql = 'SELECT id, username, nickname, email, avatar, create_at, update_at FROM users WHERE id = ?';
    const [user] = await db.query(sql, [req.query.id]);
    if (user.length === 0) {
        return res.send(ApiResponse.error(201, '未识别到该用户'));
    }
    return res.send(ApiResponse.success(200, '用户信息获取成功', user[0]));
};

/**
 * 处理用户注册请求
 * @param {Object} req - HTTP请求对象，包含body参数(username, password)
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回注册结果的API响应
 */
exports.handleUserRegister = async (req, res) => {

    const { username, password, nickname = username, email = null, avatar = null } = req.body;

    // SQL 
    const query_user = 'SELECT * FROM users WHERE username = ?'
    const register_user = 'INSERT INTO users (username, password, nickname, email, avatar, create_at, update_at) VALUES (?, ?, ?, ?, ?, now(), now())';

    const [users] = await db.query(query_user, [username])

    if (users.length !== 0) {
        return res.send(ApiResponse.success(200, '该用户名已存在，请更换！'))
    }

    // 对用户密码进行加密处理
    const password_pro = bcrypt.hashSync(password, 10);

    const [result] = await db.query(register_user, [username, password_pro, nickname, email, avatar])

    if (result.affectedRows === 1) {
        return res.send(ApiResponse.success(200, '注册成功！'))
    } else {
        return res.send(ApiResponse.error(500, '注册失败！'))
    }
}

/**
 * 处理用户登录请求的异步函数
 * @param {Object} req - Express请求对象，包含用户提交的登录信息
 * @param {Object} res - Express响应对象，用于返回登录结果
 */
exports.handleUserLogin = async (req, res) => {
    // 查询用户信息的SQL语句，通过用户名查找用户
    const query_user = 'SELECT * FROM users WHERE username = ?'

    // 从请求体中解构出用户名和密码
    const { username, password } = req.body

    // 执行数据库查询，获取用户信息
    const [result] = await db.query(query_user, [username])

    // 检查用户是否存在，不存在则返回错误响应
    if (result.length === 0) return res.send(ApiResponse.error(500, '用户不存在！'))

    // 使用bcrypt比较提交的密码与数据库中存储的哈希密码
    const compareResult = bcrypt.compareSync(password, result[0].password)

    // 密码验证失败时返回错误响应
    if (!compareResult) return res.send(ApiResponse.error(500, '密码错误！'))

    // 准备用于生成JWT令牌的用户信息对象（仅包含必要字段）
    const userForToken = {
        id: result[0].id,
        username: result[0].username,
        nickname: result[0].nickname,
        email: result[0].email,
        avatar: result[0].avatar
    }

    // 使用用户信息和密钥生成JWT令牌，设置过期时间为12小时
    const token = jwt.sign(userForToken, process.env.SECRET_KEY, { expiresIn: '12h' })

    // 返回登录成功响应，包含生成的令牌
    return res.send(ApiResponse.success(200, '登录成功！', token))
}

/**
 * 处理用户查询请求
 * @param {Object} req - HTTP请求对象，包含查询参数
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回查询结果的API响应
 */
exports.handleUserSearch = async (req, res) => {
    const { username } = req.query;

    const sql = 'SELECT id, username, nickname, email, avatar, create_at, update_at FROM users WHERE username = ?';

    const [user] = await db.query(sql, [username]);

    if (user.length === 0) {
        return res.send(ApiResponse.success(200, '未找到匹配的用户', []));
    }
    return res.send(ApiResponse.success(200, '用户列表获取成功', user));
}

/**
 * 处理用户身份过期校验请求
 * @param {Object} req - HTTP请求对象，包含查询参数
 * @param {Object} res - HTTP响应对象
 * @returns {Object} 返回校验结果的API响应
 */
exports.handleUserVerify = async (req, res) => {
    // 从请求头中获取 Authorization
    const authHeader = req.headers['authorization'];

    // 检查是否存在 Authorization 头
    if (!authHeader) {
        return res.send(ApiResponse.success(200, '令牌校验失败，或者无效', false));
    }

    // 按空格拆分，格式应为 "Bearer <token>"
    const parts = authHeader.split(' ');

    // 校验格式是否正确：必须是两部分，且第一部分是 Bearer
    if (parts.length !== 2 || parts[0] !== 'Bearer') {
        return res.send(ApiResponse.success(200, '令牌校验失败，或者无效', false));
    }

    // 获取真正的 token（第二部分）
    const token = parts[1];

    // 检查 token 是否存在
    if (!token) {
        return res.send(ApiResponse.success(200, '令牌校验失败，或者无效', false));
    }

    try {
        // 验证 token（会检查签名 + 过期时间）
        jwt.verify(token, process.env.SECRET_KEY);
        return res.send(ApiResponse.success(200, '令牌校验通过', true));
    } catch (err) {
        return res.send(ApiResponse.success(200, '令牌校验失败，或者无效', false));
    }
};